home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / phigs / ptk.lha / ptk / source / library / tsl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-01  |  63.5 KB  |  2,165 lines
  1. /*----------------------------------------------------------------------------
  2.  
  3.   Module name: traversal state list module.
  4.  
  5.   Author: Gareth Williams.
  6.  
  7.   Function: This module contains functions for inquiring information
  8.             from the PHIGS Traversal State List.
  9.  
  10.   Dependencies: 
  11.  
  12.   Internal function list: traversestruct, box
  13.  
  14.   External function list: ptk_boundingbox
  15.  
  16.   Hashtables used: none.
  17.  
  18.   Modification history: (Version), (Date), (name), (Description).
  19.  
  20.   1.0, 4th September 1991, G. Williams, First version.
  21.  
  22.   2.0, June 1992, G. Williams, Converted to ISO PHIGS C.
  23.  
  24. ----------------------------------------------------------------------------*/
  25.  
  26. #include <stdio.h>
  27. #include <math.h>
  28. #include <phigs.h>
  29. #include "ptk.h"
  30.  
  31. /*--------------------------------------------------------------------------*/
  32.  
  33. #ifdef SUN
  34. typedef struct ptkstslplus
  35. {
  36.   /* PHIGS PLUS bits */
  37.   Pint datamapindex;
  38.   Pint backintindex;
  39.   Pint backdatamapindex;
  40.   Pint reflindex;
  41.   Pint backreflindex;
  42.   Pint paramsurfindex;
  43.   Pgcolr linecolour;
  44.   Pint lineshadmeth;
  45.   Pasf linecolourasf;
  46.   Pasf lineshadmethasf;
  47.   Pgcolr markercolour;
  48.   Pasf markercolourasf;
  49.   Pgcolr textcolour;
  50.   Pasf textcolourasf;
  51.   Pdisting_mode distingmode;
  52.   Pcull_mode cullmode;
  53.   Pgcolr intcolour;
  54.   Pint intshadmeth;
  55.   Pint datamapmeth;
  56.   Prefl_props reflprops;
  57.   Pint reflmodel;
  58.   Pasf intcolourasf;
  59.   Pasf intshadmethasf;
  60.   Pasf datamapmethasf;
  61.   Pasf reflpropsasf;
  62.   Pasf reflmodelasf;
  63.   Pint_style backintstyle;
  64.   Pint backintstyleindex;
  65.   Pgcolr backintcolour;
  66.   Pint backintshadmeth;
  67.   Pint backdatamapmeth;
  68.   Prefl_props backreflprops;
  69.   Pint backreflmodel;
  70.   Pasf backintstyleasf;
  71.   Pasf backintstyleindexasf;
  72.   Pasf backintcolourasf;
  73.   Pasf backintshadmethasf;
  74.   Pasf backdatamapmethasf;
  75.   Pasf backreflpropsasf;
  76.   Pasf backreflmodelasf;
  77.   Pint_list lightsrcstate;
  78.   Pint lights[100];
  79.   Pgcolr edgecolour;
  80.   Pasf edgecolourasf;
  81.   Pint curveapproxtype;
  82.   Pfloat curveapproxval;
  83.   Pasf curveapproxasf;
  84.   Pint surfapproxtype;
  85.   Pfloat surfapproxuval;
  86.   Pfloat surfapproxvval;
  87.   Pasf surfapproxval;
  88.   Pint parasurftype;
  89.   Ppara_surf_characs parasurfdata;
  90.   Pasf parasurfasf;
  91.   Pint renderingmodel;
  92.   Pint dcueindex;
  93.   Pint colourmapindex;
  94. } ptkstslplus;
  95. #endif
  96.  
  97. typedef struct ptkstsl
  98. {
  99.   Pline_attrs lnattr;
  100.   Pmarker_attrs mkattr;
  101.   Pint_attrs interattr;
  102.   Pedge_attrs edgeattr;
  103.   Ptext_bundle txbundl;
  104.   Pint textindex;
  105.   Pasf textfontasf;
  106.   Pasf textprecasf;
  107.   Pasf charexpanasf;
  108.   Pasf charspaceasf;
  109.   Pasf textcolourasf;
  110.   Pfloat charheight;
  111.   Ppoint charup;
  112.   Ptext_path textpath;
  113.   Ptext_align textalign;
  114.   Pfloat annocharheight;
  115.   Ppoint annocharup;
  116.   Ptext_path annotextpath;
  117.   Ptext_align annotextalign;
  118.   Pint annostyle;
  119.   Pfloat_size patsize;
  120.   Ppoint3 patrefpt;
  121.   Ppoint3 patvec[2];
  122.   Pint pickid;
  123.   Pint viewindex;
  124.   Pint hlhsrid;
  125.   Pint_list nameset;
  126.   Pint names[100];
  127.   Pmatrix3 globaltran;
  128.   Pmatrix3 localtran;
  129.   Pint modelclipoperator;
  130.   Phalf_space_list3 modelclipvolume;
  131.   Pclip_ind modelclipindicator;
  132. #ifdef SUN
  133.   ptkstslplus tslplus;
  134. #endif
  135. } ptkstsl;
  136.  
  137. typedef struct ptkstslstack 
  138. {
  139.   ptkstsl tsl;
  140.   struct ptkstslstack *next;
  141. } ptkstslstack;
  142.  
  143. typedef struct ptkstslpos 
  144. {
  145.   Pint stid;
  146.   Pint elemid;
  147.   struct ptkstslpos *next;
  148. } ptkstslpos;
  149.  
  150. typedef struct ptkstslbox 
  151. {
  152.   Plimit3 box;
  153.   struct ptkstslbox *next;
  154. } ptkstslbox;
  155.  
  156. static ptkstslstack *tslstack = NULL;
  157. static ptkstslpos *tslpos = NULL;
  158. static ptkstslbox *tslbox = NULL;
  159. static ptkstsl tsl;
  160. static Plimit3 boundbox;
  161. static Pint curstid, curelemid;
  162. static Pint firststid, firstelemid;
  163. #ifdef HP
  164. static Pstore hpstore;
  165. static ptkboolean hpstorecreated = FALSE;
  166. #endif
  167.  
  168. /*--------------------------------------------------------------------------*/
  169.  
  170. static void stackpos()
  171. /*
  172. ** \blurb{Saves the name and status of the currently open structure,
  173. ** so it can be restored again by 'unstackstruct'.}
  174. */
  175. {
  176.   ptkstslpos *positem;
  177.  
  178.   positem = (ptkstslpos *)malloc(sizeof(ptkstslpos));
  179.   positem->next = tslpos;
  180.   tslpos = positem;
  181.   positem->stid = curstid;
  182.   positem->elemid = curelemid;
  183. }  /* stackpos */
  184.  
  185. /*--------------------------------------------------------------------------*/
  186.  
  187. static void unstackpos()
  188. /*
  189. ** \blurb{Remove the structure from the top of the stack and
  190. ** restore the open structure and element pointer.}
  191. */
  192. {
  193.   ptkstslpos *positem;
  194.  
  195.   if (tslpos != NULL)
  196.   {
  197.     curstid = tslpos->stid;
  198.     curelemid = tslpos->elemid;
  199.     positem = tslpos->next;
  200.     free(tslpos);
  201.     tslpos = positem;
  202.   }
  203. }  /* unstackpos */
  204.  
  205. /*--------------------------------------------------------------------------*/
  206.  
  207. static void testpoint(C(Ppoint3 *) p, C(Plimit3 *) box)
  208. PreANSI(Ppoint3 *p)
  209. PreANSI(Plimit3 *box)
  210. /*
  211. ** \param{Ppoint3 *}{p}{point.}
  212. ** \param{Plimit3 *}{boxptr}{bounding box structure}
  213. ** \blurb{Tests if point `p' is outside bounding box and
  214. ** if so adjusts bounding box to include it.}
  215. */
  216. {
  217.   if (p->x < box->x_min)
  218.     box->x_min = p->x;
  219.   if (p->y < box->y_min)
  220.     box->y_min = p->y;
  221.   if (p->z < box->z_min)
  222.     box->z_min = p->z;
  223.   if (p->x > box->x_max)
  224.     box->x_max = p->x;
  225.   if (p->y > box->y_max)
  226.     box->y_max = p->y;
  227.   if (p->z > box->z_max)
  228.     box->z_max = p->z;
  229.  
  230. }
  231.  
  232. /*--------------------------------------------------------------------------*/
  233.  
  234. static void addnameset(C(Pint_list *) addnames, C(Pint_list *) nameset)
  235. PreANSI(Pint_list *addnames)
  236. PreANSI(Pint_list *nameset)
  237. {
  238.   Pint i;
  239.  
  240.   for (i = 0; i < addnames->num_ints; i++)
  241.   {
  242.     if (inintlst(addnames->ints[i], nameset) == -1)
  243.     {
  244.       nameset->ints[nameset->num_ints] = addnames->ints[i];
  245.       nameset->num_ints++;
  246.     }
  247.   }
  248. }  /* addnameset */
  249.  
  250. /*--------------------------------------------------------------------------*/
  251.  
  252. static void removenameset(C(Pint_list *) removenames, C(Pint_list *) nameset)
  253. PreANSI(Pint_list *removenames)
  254. PreANSI(Pint_list *nameset)
  255. {
  256.   Pint i, j, findex;
  257.  
  258.   for (i = 0; i < removenames->num_ints; i++)
  259.   {
  260.     if ((findex = inintlst(removenames->ints[i], nameset)) != -1)
  261.     {
  262.       for (j = findex; j < nameset->num_ints - 1; j++)
  263.       {
  264.         nameset->ints[j] = nameset->ints[j + 1];
  265.       }
  266.       nameset->num_ints--;
  267.     }
  268.   }
  269. }  /* removenameset */
  270.  
  271. /*--------------------------------------------------------------------------*/
  272.  
  273. static ptkboolean tsltraverseelement(C(Pint *) execid, C(Plimit3 *) bbox)
  274. PreANSI(Pint *execid)
  275. PreANSI(Plimit3 *bbox)
  276. {
  277.   Pint i, j, k, error;
  278.   Pmatrix3 compxform;
  279.   Pstore store;
  280.   ptkselcontent elcont;
  281.   ptkboolean result;
  282.   Paspect attrid;
  283.   Pasf asf;
  284.   Ppoint3 pt;
  285.  
  286.   result = FALSE;
  287.    *execid = 0;
  288.  
  289.     /* find out type and contents of element */
  290. #ifndef HP
  291.     pcreate_store(&error, &store);
  292.     ptk_inqcurelemtypesizecontent(store, &error, &elcont);
  293. #else
  294.     if (!hpstorecreated)
  295.     {
  296.       pcreate_store(&error, &hpstore);
  297.       hpstorecreated = TRUE;
  298.     }
  299.     ptk_inqcurelemtypesizecontent(hpstore, &error, &elcont);
  300. #endif
  301.     if (error == 0) 
  302.     {
  303.       /* not all cases have been implemented yet */
  304.       switch (elcont.eltype) 
  305.       {
  306.  
  307.       case PELEM_POLYLINE3:
  308.       case PELEM_POLYMARKER3:
  309.       case PELEM_FILL_AREA3:
  310.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  311.         for (j = 0; j < elcont.eldata->point_list3.num_points; j++) 
  312.         {
  313.           pt = ptk_transform3(compxform, 
  314.                               &elcont.eldata->point_list3.points[j]);
  315.       testpoint(&pt, bbox);
  316.     }
  317.     break;
  318.  
  319.       case PELEM_POLYLINE:
  320.       case PELEM_POLYMARKER:
  321.       case PELEM_FILL_AREA:
  322.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  323.         for (j = 0; j < elcont.eldata->point_list.num_points; j++) 
  324.         {
  325.           pt = ptk_point3(elcont.eldata->point_list.points[j].x, 
  326.                           elcont.eldata->point_list.points[j].y, 0.0);
  327.           pt = ptk_transform3(compxform, &pt);
  328.       testpoint(&pt, bbox);
  329.     }
  330.     break;
  331.  
  332.       case PELEM_TEXT3:   /* do nothing */
  333.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  334.         /* inquire text extent assuming text font 1, stroke precision */
  335.         {
  336.           Pint err;
  337.           char *str;
  338.           Prect rect;
  339.           Ppoint offset;
  340.           Pint wstype;
  341.           Pmatrix3 charupmat, txdirmat, txmat;
  342.           Ppoint3 txpt;
  343.           Pfloat angle;
  344.  
  345.           str = elcont.eldata->text3.char_string;
  346. #ifndef SUN
  347.           /* do for HP and PEXSI */
  348.           rect.p = ptk_point(0.0, 0.0);
  349.           rect.q = ptk_point(0.0, 0.0);
  350. #endif
  351. #ifdef SUN
  352.           wstype = phigs_ws_type_create(phigs_ws_type_x_tool, 0); 
  353.           pinq_text_extent(wstype, 1, tsl.txbundl.char_expan, 
  354.             tsl.txbundl.char_space, 
  355.             tsl.charheight, tsl.textpath, tsl.textalign.hor, 
  356.             tsl.textalign.vert, str, &err, &rect, &offset);
  357. #endif
  358.           /* make 2 matrices, one for character up vector
  359.           ** and one for text position and direction vectors.
  360.           */
  361.           ptk_unitmatrix3(charupmat);
  362.           ptk_unitmatrix3(txdirmat);
  363.  
  364.           /* rotate text extent rectangle about z axis to account for the
  365.           ** character up vector.
  366.           */
  367.           angle = (Pfloat)atan2(tsl.charup.x, tsl.charup.y);
  368.           angle *= -180.0/3.1412;
  369.           ptk_rotate3(angle, PTKEZAXIS, PTYPE_REPLACE, charupmat);
  370.  
  371.           txdirmat[0][0] = elcont.eldata->text3.dir[0].delta_x;
  372.           txdirmat[1][0] = elcont.eldata->text3.dir[0].delta_y;
  373.           txdirmat[2][0] = elcont.eldata->text3.dir[0].delta_z;
  374.           txdirmat[0][1] = elcont.eldata->text3.dir[1].delta_x;
  375.           txdirmat[1][1] = elcont.eldata->text3.dir[1].delta_y;
  376.           txdirmat[2][1] = elcont.eldata->text3.dir[1].delta_z;
  377.           txdirmat[0][3] = elcont.eldata->text3.pos.x;
  378.           txdirmat[1][3] = elcont.eldata->text3.pos.y;
  379.           txdirmat[2][3] = elcont.eldata->text3.pos.z;
  380.         
  381.           ptk_concatenatematrix3(PTYPE_POSTCONCAT, txdirmat, charupmat, 
  382.                                  txmat);
  383.           txpt = ptk_point3(rect.p.x, rect.p.y, 0.0);
  384.           txpt = ptk_transform3(txmat, &txpt);
  385.           txpt = ptk_transform3(compxform, &txpt);
  386.           testpoint(&txpt, bbox);
  387.           txpt = ptk_point3(rect.q.x, rect.q.y, 0.0);
  388.           txpt = ptk_transform3(txmat, &txpt);
  389.           txpt = ptk_transform3(compxform, &txpt);
  390.           testpoint(&pt, bbox);
  391.           txpt = ptk_point3(rect.p.x, rect.q.y, 0.0);
  392.           txpt = ptk_transform3(txmat, &txpt);
  393.           txpt = ptk_transform3(compxform, &txpt);
  394.           testpoint(&pt, bbox);
  395.           txpt = ptk_point3(rect.q.x, rect.p.y, 0.0);
  396.           txpt = ptk_transform3(txmat, &txpt);
  397.           txpt = ptk_transform3(compxform, &txpt);
  398.           testpoint(&pt, bbox);
  399.         }              
  400.     break;
  401.  
  402.       case PELEM_TEXT:   /* do nothing */
  403.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  404.         /* inquire text extent assuming text font 1, stroke precision */
  405.         {
  406.           Pint err;
  407.           char *str;
  408.           Prect rect;
  409.           Ppoint offset;
  410.           Pint wstype;
  411.           Pmatrix3 charupmat;
  412.           Ppoint3 txpt;
  413.           Pfloat angle;
  414.  
  415.           str = elcont.eldata->text.char_string;
  416. #ifndef SUN
  417.           /* do for HP and PEXSI */
  418.           rect.p = ptk_point(0.0, 0.0);
  419.           rect.q = ptk_point(0.0, 0.0);
  420. #endif
  421. #ifdef SUN
  422.           wstype = phigs_ws_type_create(phigs_ws_type_x_tool, 0); 
  423.           pinq_text_extent(wstype, 1, tsl.txbundl.char_expan, 
  424.             tsl.txbundl.char_space, 
  425.             tsl.charheight, tsl.textpath, tsl.textalign.hor, 
  426.             tsl.textalign.vert, str, &err, &rect, &offset);
  427. #endif
  428.           /* make 1 matrix for character up vector
  429.           ** and text position.
  430.           */
  431.           ptk_unitmatrix3(charupmat);
  432.           angle = (Pfloat)atan2(tsl.charup.x, tsl.charup.y);
  433.           angle *= -180.0/3.1412;
  434.           ptk_rotate3(angle, PTKEZAXIS, PTYPE_REPLACE, charupmat);
  435.  
  436.           charupmat[0][3] = elcont.eldata->text.pos.x;
  437.           charupmat[1][3] = elcont.eldata->text.pos.y;
  438.           charupmat[2][3] = 0.0;
  439.         
  440.           txpt = ptk_point3(rect.p.x, rect.p.y, 0.0);
  441.           txpt = ptk_transform3(charupmat, &txpt);
  442.           txpt = ptk_transform3(compxform, &txpt);
  443.           testpoint(&txpt, bbox);
  444.           txpt = ptk_point3(rect.q.x, rect.q.y, 0.0);
  445.           txpt = ptk_transform3(charupmat, &txpt);
  446.           txpt = ptk_transform3(compxform, &txpt);
  447.           testpoint(&txpt, bbox);
  448.           txpt = ptk_point3(rect.p.x, rect.q.y, 0.0);
  449.           txpt = ptk_transform3(charupmat, &txpt);
  450.           txpt = ptk_transform3(compxform, &txpt);
  451.           testpoint(&txpt, bbox);
  452.           txpt = ptk_point3(rect.q.x, rect.p.y, 0.0);
  453.           txpt = ptk_transform3(charupmat, &txpt);
  454.           txpt = ptk_transform3(compxform, &txpt);
  455.           testpoint(&txpt, bbox);
  456.         }              
  457.     break;
  458.  
  459.       case PELEM_ANNO_TEXT_REL3:
  460.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  461.         /* inquire text extent assuming text font 1, stroke precision */
  462.         {
  463.           Pint err;
  464.           char *str;
  465.           Prect rect;
  466.           Ppoint offset;
  467.           Pint wstype;
  468.           Pmatrix3 charupmat;
  469.           Ppoint3 txpt;
  470.           Pfloat angle;
  471.  
  472.           str = elcont.eldata->anno_text_rel3.char_string;
  473. #ifndef SUN
  474.           /* do for HP and PEXSI */
  475.           rect.p = ptk_point(0.0, 0.0);
  476.           rect.q = ptk_point(0.0, 0.0);
  477. #endif
  478. #ifdef SUN
  479.           wstype = phigs_ws_type_create(phigs_ws_type_x_tool, 0); 
  480.           pinq_text_extent(wstype, 1, tsl.txbundl.char_expan, 
  481.             tsl.txbundl.char_space, 
  482.             tsl.annocharheight, tsl.annotextpath, 
  483.             tsl.annotextalign.hor, tsl.annotextalign.vert,
  484.             str, &err, &rect, &offset);
  485. #endif
  486.           /* make 2 matrices, one for character up vector
  487.           ** and text position, and one for direction vectors.
  488.           */
  489.           ptk_unitmatrix3(charupmat);
  490.           angle = (Pfloat)atan2(tsl.charup.x, tsl.charup.y);
  491.           angle *= -180.0/3.1412;
  492.           ptk_rotate3(angle, PTKEZAXIS, PTYPE_REPLACE, charupmat);
  493.  
  494.           /* lead line - annotation style, include ref_pt */
  495.           charupmat[0][3] = elcont.eldata->anno_text_rel3.ref_point.x + 
  496.                             elcont.eldata->anno_text_rel3.offset.delta_x;
  497.           charupmat[1][3] = elcont.eldata->anno_text_rel3.ref_point.y + 
  498.                             elcont.eldata->anno_text_rel3.offset.delta_y;
  499.           charupmat[2][3] = elcont.eldata->anno_text_rel3.ref_point.z + 
  500.                             elcont.eldata->anno_text_rel3.offset.delta_z;
  501.  
  502.           txpt = ptk_point3(rect.p.x, rect.p.y, 0.0);
  503.           txpt = ptk_transform3(charupmat, &txpt);
  504.           txpt = ptk_transform3(compxform, &txpt);
  505.           testpoint(&txpt, bbox);
  506.           txpt = ptk_point3(rect.q.x, rect.q.y, 0.0);
  507.           txpt = ptk_transform3(charupmat, &txpt);
  508.           txpt = ptk_transform3(compxform, &txpt);
  509.           testpoint(&txpt, bbox);
  510.           txpt = ptk_point3(rect.p.x, rect.q.y, 0.0);
  511.           txpt = ptk_transform3(charupmat, &txpt);
  512.           txpt = ptk_transform3(compxform, &txpt), 
  513.           testpoint(&txpt, bbox);
  514.           txpt = ptk_point3(rect.q.x, rect.p.y, 0.0);
  515.           txpt = ptk_transform3(charupmat, &txpt);
  516.           txpt = ptk_transform3(compxform, &txpt);
  517.           testpoint(&txpt, bbox);
  518.         }              
  519.     break;
  520.  
  521.       case PELEM_ANNO_TEXT_REL:   /* do nothing */
  522.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  523.         /* inquire text extent assuming text font 1, stroke precision */
  524.         {
  525.           Pint err;
  526.           char *str;
  527.           Prect rect;
  528.           Ppoint offset;
  529.           Pint wstype;
  530.           Pmatrix3 charupmat;
  531.           Ppoint3 txpt;
  532.           Pfloat angle;
  533.  
  534.           str = elcont.eldata->anno_text_rel.char_string;
  535. #ifndef SUN
  536.           /* do for HP and PEXSI */
  537.           rect.p = ptk_point(0.0, 0.0);
  538.           rect.q = ptk_point(0.0, 0.0);
  539. #endif
  540. #ifdef SUN
  541.           wstype = phigs_ws_type_create(phigs_ws_type_x_tool, 0); 
  542.           pinq_text_extent(wstype, 1, tsl.txbundl.char_expan, 
  543.             tsl.txbundl.char_space, 
  544.             tsl.annocharheight, tsl.annotextpath, 
  545.             tsl.annotextalign.hor, tsl.annotextalign.vert,
  546.             str, &err, &rect, &offset);
  547. #endif
  548.           /* make 2 matrices, one for character up vector
  549.           ** and text position, and one for direction vectors.
  550.           */
  551.           ptk_unitmatrix3(charupmat);
  552.           angle = (Pfloat)atan2(tsl.charup.x, tsl.charup.y);
  553.           angle *= -180.0/3.1412;
  554.           ptk_rotate3(angle, PTKEZAXIS, PTYPE_REPLACE, charupmat);
  555.  
  556.           /* lead line - annotation style, include ref_pt */
  557.           charupmat[0][3] = elcont.eldata->anno_text_rel.ref_point.x + 
  558.                             elcont.eldata->anno_text_rel.offset.delta_x;
  559.           charupmat[1][3] = elcont.eldata->anno_text_rel.ref_point.y + 
  560.                             elcont.eldata->anno_text_rel.offset.delta_y;
  561.           charupmat[2][3] = 0.0;
  562.         
  563.           txpt = ptk_point3(rect.p.x, rect.p.y, 0.0);
  564.           txpt = ptk_transform3(charupmat, &txpt);
  565.           txpt = ptk_transform3(compxform, &txpt);
  566.           testpoint(&txpt, bbox);
  567.           txpt = ptk_point3(rect.q.x, rect.q.y, 0.0);
  568.           txpt = ptk_transform3(charupmat, &txpt);
  569.           txpt = ptk_transform3(compxform, &txpt);
  570.           testpoint(&txpt, bbox);
  571.           txpt = ptk_point3(rect.p.x, rect.q.y, 0.0);
  572.           txpt = ptk_transform3(charupmat, &txpt);
  573.           txpt = ptk_transform3(compxform, &txpt);
  574.           testpoint(&txpt, bbox);
  575.           txpt = ptk_point3(rect.q.x, rect.p.y, 0.0);
  576.           txpt = ptk_transform3(charupmat, &txpt);
  577.           txpt = ptk_transform3(compxform, &txpt);
  578.           testpoint(&txpt, bbox);
  579.         }              
  580.     break;
  581.  
  582.       case PELEM_FILL_AREA_SET3:   
  583.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  584.         for (j = 0; j < elcont.eldata->point_list_list3.num_point_lists; j++) 
  585.         {
  586.           for (k = 0; k < elcont.eldata->point_list_list3.point_lists[j].num_points; k++)
  587.       {
  588.             pt = ptk_transform3(compxform, 
  589.                    &elcont.eldata->point_list_list3.point_lists[j].points[k]), 
  590.             testpoint(&pt, bbox);
  591.           }
  592.     }
  593.     break;
  594.  
  595.       case PELEM_FILL_AREA_SET:   /* do nothing */
  596.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  597.     {
  598.           Ppoint fpt;
  599.  
  600.           for (j = 0; j < elcont.eldata->point_list_list.num_point_lists; j++) 
  601.           {        
  602.             for (k = 0; k < elcont.eldata->point_list_list.point_lists[j].num_points; k++)
  603.             {
  604.               fpt = elcont.eldata->point_list_list.point_lists[j].points[k];  
  605.               pt = ptk_point3(fpt.x, fpt.y, 0.0);
  606.               pt = ptk_transform3(compxform, &pt);
  607.               testpoint(&pt, bbox);
  608.             }
  609.           }
  610.     }
  611.     break;
  612.  
  613.       case PELEM_CELL_ARRAY3:   
  614.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  615.         pt = ptk_transform3(compxform, &elcont.eldata->cell_array3.paral.p);
  616.         testpoint(&pt, bbox);
  617.         pt = ptk_transform3(compxform, &elcont.eldata->cell_array3.paral.q);
  618.         testpoint(&pt, bbox);
  619.         pt = ptk_transform3(compxform, &elcont.eldata->cell_array3.paral.r);
  620.         testpoint(&pt, bbox);
  621.     break;
  622.  
  623.       case PELEM_CELL_ARRAY: 
  624.     {
  625.           Ppoint cellpt;
  626.  
  627.           ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  628.           cellpt = elcont.eldata->cell_array.rect.p;
  629.           pt = ptk_point3(cellpt.x, cellpt.y, 0.0);
  630.           pt = ptk_transform3(compxform, &pt);
  631.           testpoint(&pt, bbox);
  632.           cellpt = elcont.eldata->cell_array.rect.q;  
  633.           pt = ptk_point3(cellpt.x, cellpt.y, 0.0);
  634.           pt = ptk_transform3(compxform, &pt);
  635.           testpoint(&pt, bbox);
  636.         }
  637.     break;
  638.  
  639.       case PELEM_CHAR_EXPAN:
  640.         tsl.txbundl.char_expan = elcont.eldata->float_data;
  641.     break;
  642.  
  643.       case PELEM_CHAR_SPACE:
  644.         tsl.txbundl.char_space = elcont.eldata->float_data;
  645.     break;
  646.  
  647.       case PELEM_CHAR_HT: 
  648.         tsl.charheight = elcont.eldata->float_data;
  649.     break;
  650.  
  651.       case PELEM_CHAR_UP_VEC:
  652.         tsl.charup = ptk_point(elcont.eldata->char_up_vec.delta_x, 
  653.                                 elcont.eldata->char_up_vec.delta_y);
  654.     break;
  655.  
  656.       case PELEM_TEXT_PATH:   
  657.         tsl.textpath = elcont.eldata->text_path;
  658.         break;
  659.  
  660.       case PELEM_TEXT_ALIGN:
  661.         tsl.textalign = elcont.eldata->text_align;
  662.     break;
  663.  
  664.       case PELEM_ANNO_CHAR_HT:
  665.         tsl.charheight = elcont.eldata->float_data;
  666.         break;
  667.  
  668.       case PELEM_ANNO_CHAR_UP_VEC:
  669.         tsl.annocharup = ptk_point(elcont.eldata->char_up_vec.delta_x, 
  670.                                     elcont.eldata->char_up_vec.delta_y);
  671.         break;
  672.  
  673.       case PELEM_ANNO_PATH:
  674.         tsl.annotextpath = elcont.eldata->text_path;
  675.         break;
  676.  
  677.       case PELEM_ANNO_ALIGN:
  678.         tsl.annotextalign = elcont.eldata->text_align;
  679.         break;
  680.  
  681.       case PELEM_LOCAL_MODEL_TRAN3:
  682.     ptk_concatenatematrix3(elcont.eldata->local_tran3.compose_type, 
  683.              elcont.eldata->local_tran3.matrix, tsl.localtran, tsl.localtran); 
  684.     break;
  685.  
  686.       case PELEM_LOCAL_MODEL_TRAN:
  687.     {
  688.           Pmatrix3 local4x4;
  689.           /* convert 3x3 matrix to 4x4 matrix */
  690.  
  691.           ptk_matrixtomatrix3(elcont.eldata->local_tran.matrix, local4x4);
  692.           ptk_concatenatematrix3(elcont.eldata->local_tran.compose_type, 
  693.                local4x4, tsl.localtran, tsl.localtran); 
  694.         }
  695.     break;
  696.  
  697.       case PELEM_GLOBAL_MODEL_TRAN3:
  698.      memcpy(tsl.globaltran, elcont.eldata->global_tran3, sizeof(Pmatrix3));
  699.     break;
  700.  
  701.       case PELEM_GLOBAL_MODEL_TRAN:
  702.     {
  703.           Pmatrix3 global4x4;
  704.  
  705.           ptk_matrixtomatrix3(elcont.eldata->global_tran, global4x4);
  706.           memcpy(tsl.globaltran, global4x4, sizeof(Pmatrix3));
  707.         }
  708.     break;
  709.  
  710.       case PELEM_EXEC_STRUCT:
  711.         result = TRUE;
  712.         *execid = elcont.eldata->int_data;
  713.     break;
  714.  
  715.       case PELEM_NIL:   /* do nothing */
  716.     break;
  717.  
  718.       case PELEM_LINE_IND:
  719.         tsl.lnattr.ind = elcont.eldata->int_data;
  720.         break;
  721.  
  722.       case PELEM_MARKER_IND:
  723.         tsl.mkattr.ind = elcont.eldata->int_data;
  724.         break;
  725.  
  726.       case PELEM_TEXT_IND:
  727.         tsl.textindex = elcont.eldata->int_data;
  728.         break;
  729.  
  730.       case PELEM_INT_IND:
  731.         tsl.interattr.ind = elcont.eldata->int_data;
  732.         break;
  733.  
  734.       case PELEM_EDGE_IND:
  735.         tsl.edgeattr.ind = elcont.eldata->int_data;
  736.         break;
  737.  
  738.       case PELEM_LINETYPE:
  739.         tsl.lnattr.bundle.type = elcont.eldata->int_data;
  740.         break;
  741.  
  742.       case PELEM_LINEWIDTH:
  743.         tsl.lnattr.bundle.width = elcont.eldata->float_data;
  744.         break;
  745.  
  746.       case PELEM_LINE_COLR_IND:
  747.         tsl.lnattr.bundle.colr_ind = elcont.eldata->int_data;
  748.         break;
  749.  
  750.       case PELEM_MARKER_TYPE:
  751.         tsl.mkattr.bundle.type = elcont.eldata->int_data;
  752.         break;
  753.  
  754.       case PELEM_MARKER_SIZE:
  755.         tsl.mkattr.bundle.size = elcont.eldata->float_data;
  756.         break;
  757.  
  758.       case PELEM_MARKER_COLR_IND:
  759.         tsl.mkattr.bundle.colr_ind = elcont.eldata->int_data;
  760.         break;
  761.  
  762.       case PELEM_TEXT_FONT:
  763.         tsl.txbundl.font = elcont.eldata->int_data;
  764.         break;
  765.  
  766.       case PELEM_TEXT_PREC:
  767.         tsl.txbundl.prec = elcont.eldata->text_prec;
  768.         break;
  769.  
  770.       case PELEM_TEXT_COLR_IND:
  771.         tsl.txbundl.colr_ind = elcont.eldata->int_data;
  772.         break;
  773.  
  774.       case PELEM_ANNO_STYLE:
  775.         tsl.annostyle = elcont.eldata->int_data;
  776.         break;
  777.  
  778.       case PELEM_INT_STYLE:
  779.         tsl.interattr.bundle.style = elcont.eldata->int_style;
  780.         break;
  781.  
  782.       case PELEM_INT_STYLE_IND:
  783.         tsl.interattr.bundle.style_ind = elcont.eldata->int_data;
  784.         break;
  785.  
  786.       case PELEM_INT_COLR_IND:
  787.         tsl.interattr.bundle.colr_ind = elcont.eldata->int_data;
  788.         break;
  789.  
  790.       case PELEM_EDGE_FLAG:
  791.         tsl.edgeattr.bundle.flag = elcont.eldata->edge_flag;
  792.         break;
  793.  
  794.       case PELEM_EDGETYPE:
  795.         tsl.edgeattr.bundle.type = elcont.eldata->int_data;
  796.         break;
  797.  
  798.       case PELEM_EDGEWIDTH:
  799.         tsl.edgeattr.bundle.width = elcont.eldata->float_data;
  800.         break;
  801.  
  802.       case PELEM_EDGE_COLR_IND:
  803.         tsl.edgeattr.bundle.colr_ind = elcont.eldata->int_data;
  804.         break;
  805.  
  806.       case PELEM_PAT_SIZE:
  807.         tsl.patsize = elcont.eldata->pat_size;
  808.         break;
  809.  
  810.       case PELEM_PAT_REF_POINT_VECS:
  811.         tsl.patrefpt = elcont.eldata->pat_ref_point_vecs.ref_point;
  812.         tsl.patvec[0] = ptk_vec3topt3(&elcont.eldata->pat_ref_point_vecs.ref_vec[0]);
  813.         tsl.patvec[1] = ptk_vec3topt3(&elcont.eldata->pat_ref_point_vecs.ref_vec[1]);
  814.         break;
  815.  
  816.       case PELEM_PAT_REF_POINT:
  817.         tsl.patrefpt = ptk_point3(elcont.eldata->pat_ref_point.x,
  818.                                   elcont.eldata->pat_ref_point.y, 0.0);
  819.         break;
  820.  
  821.       case PELEM_ADD_NAMES_SET:
  822.         addnameset(&elcont.eldata->names, &tsl.nameset);
  823.         break;
  824.  
  825.       case PELEM_REMOVE_NAMES_SET:
  826.         removenameset(&elcont.eldata->names, &tsl.nameset);
  827.         break;
  828.  
  829.       case PELEM_INDIV_ASF:
  830.         attrid = elcont.eldata->asf.id; 
  831.         asf = elcont.eldata->asf.source;
  832.         switch (attrid)
  833.     {
  834.           case PASPECT_LINETYPE:
  835.             tsl.lnattr.type_asf = asf;
  836.             break;
  837.  
  838.           case PASPECT_LINEWIDTH:
  839.             tsl.lnattr.width_asf = asf;
  840.             break;
  841.  
  842.           case PASPECT_LINE_COLR_IND:
  843.             tsl.lnattr.colr_ind_asf = asf;
  844.             break;
  845.  
  846.           case PASPECT_MARKER_TYPE:
  847.             tsl.mkattr.type_asf = asf;
  848.             break;
  849.  
  850.           case PASPECT_MARKER_SIZE:
  851.             tsl.mkattr.size_asf = asf;
  852.             break;
  853.  
  854.           case PASPECT_MARKER_COLR_IND:
  855.             tsl.mkattr.colr_ind_asf = asf;
  856.             break;
  857.  
  858.           case PASPECT_TEXT_FONT:
  859.             tsl.textfontasf = asf;        
  860.             break;
  861.  
  862.           case PASPECT_TEXT_PREC:
  863.             tsl.textprecasf = asf;        
  864.             break;
  865.  
  866.           case PASPECT_CHAR_EXPAN:
  867.             tsl.charexpanasf = asf;        
  868.             break;
  869.  
  870.           case PASPECT_CHAR_SPACE:
  871.             tsl.charspaceasf = asf;        
  872.             break;
  873.  
  874.           case PASPECT_TEXT_COLR_IND:
  875.             tsl.textcolourasf = asf;        
  876.             break;
  877.  
  878.           case PASPECT_INT_STYLE:
  879.             tsl.interattr.style_asf = asf;
  880.             break;
  881.  
  882.           case PASPECT_INT_STYLE_IND:
  883.             tsl.interattr.style_ind_asf = asf;
  884.             break;
  885.  
  886.           case PASPECT_INT_COLR_IND:
  887.             tsl.interattr.colr_ind_asf = asf;
  888.             break;
  889.  
  890.           case PASPECT_EDGE_FLAG:
  891.             tsl.edgeattr.flag_asf = asf;
  892.             break;
  893.  
  894.           case PASPECT_EDGETYPE:
  895.             tsl.edgeattr.type_asf = asf;
  896.             break;
  897.  
  898.           case PASPECT_EDGEWIDTH:
  899.             tsl.edgeattr.width_asf = asf;
  900.             break;
  901.  
  902.           case PASPECT_EDGE_COLR_IND:
  903.             tsl.edgeattr.colr_ind_asf = asf;
  904.             break;
  905.         }
  906.         break;
  907.  
  908.       case PELEM_HLHSR_ID:
  909.         tsl.hlhsrid = elcont.eldata->int_data;
  910.         break;
  911.  
  912.       case PELEM_MODEL_CLIP_VOL3:
  913.         break;
  914.  
  915.       case PELEM_MODEL_CLIP_VOL:
  916.         break;
  917.  
  918.       case PELEM_MODEL_CLIP_IND:
  919.         break;
  920.  
  921.       case PELEM_RESTORE_MODEL_CLIP_VOL:
  922.         break;
  923.  
  924.       case PELEM_VIEW_IND:
  925.         tsl.viewindex = elcont.eldata->int_data;
  926.         break;
  927.  
  928.       case PELEM_GSE:
  929.         break;
  930.  
  931.       case PELEM_PICK_ID:
  932.         tsl.pickid = elcont.eldata->int_data;
  933.         break;
  934.  
  935.       /* PHIGS PLUS bits */
  936. #ifdef SUN
  937.       case PELEM_POLYLINE_SET3_DATA:
  938.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  939.         for (j = 0; j < elcont.eldata->plsd3.npl; j++) 
  940.         {
  941.           for (k = 0; k < elcont.eldata->plsd3.vdata[j].num_vertices; k++)
  942.       {
  943.             switch (elcont.eldata->plsd3.vflag)
  944.         {
  945.               case PVERT_COORD:
  946.                 pt = elcont.eldata->plsd3.vdata[j].vertex_data.points[k];
  947.                 break;
  948.  
  949.               case PVERT_COORD_COLOUR:
  950.                 pt = elcont.eldata->plsd3.vdata[j].vertex_data.ptcolrs[k].point;
  951.                 break;
  952.             }
  953.             pt = ptk_transform3(compxform, &pt);
  954.             testpoint(&pt, bbox);
  955.           }
  956.         }        
  957.         break;
  958.  
  959.       case PELEM_FILL_AREA_SET3_DATA:
  960.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  961.         for (j = 0; j < elcont.eldata->fasd3.nfa; j++) 
  962.         {
  963.           for (k = 0; k < elcont.eldata->fasd3.vdata[j].num_vertices; k++)
  964.       {
  965.             switch (elcont.eldata->fasd3.vflag)
  966.         {
  967.               case PVERT_COORD:
  968.                 pt = elcont.eldata->fasd3.vdata[j].vertex_data.points[k];
  969.                 break;
  970.  
  971.               case PVERT_COORD_COLOUR:
  972.                 pt = elcont.eldata->fasd3.vdata[j].vertex_data.ptcolrs[k].point;
  973.                 break;
  974.  
  975.               case PVERT_COORD_NORMAL:
  976.                 pt = elcont.eldata->fasd3.vdata[j].vertex_data.ptnorms[k].point;
  977.                 break;
  978.  
  979.               case PVERT_COORD_COLOUR_NORMAL:
  980.                 pt = elcont.eldata->fasd3.vdata[j].vertex_data.ptconorms[k].point;
  981.                 break;
  982.             }
  983.             pt = ptk_transform3(compxform, &pt); 
  984.             testpoint(&pt, bbox);
  985.           }
  986.     }
  987.         break;
  988.  
  989.       case PELEM_TRI_STRIP3_DATA:
  990.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  991.         for (j = 0; j < elcont.eldata->tsd3.nv; j++) 
  992.         {
  993.           switch (elcont.eldata->tsd3.vflag)
  994.       {
  995.             case PVERT_COORD:
  996.               pt = elcont.eldata->tsd3.vdata.points[j];
  997.               break;
  998.  
  999.             case PVERT_COORD_COLOUR:
  1000.               pt = elcont.eldata->tsd3.vdata.ptcolrs[j].point;
  1001.               break;
  1002.  
  1003.             case PVERT_COORD_NORMAL:
  1004.               pt = elcont.eldata->tsd3.vdata.ptnorms[j].point;
  1005.               break;
  1006.  
  1007.             case PVERT_COORD_COLOUR_NORMAL:
  1008.               pt = elcont.eldata->tsd3.vdata.ptconorms[j].point;
  1009.               break;
  1010.           }
  1011.           pt = ptk_transform3(compxform, &pt); 
  1012.           testpoint(&pt, bbox);
  1013.     }
  1014.         break;
  1015.  
  1016.       case PELEM_QUAD_MESH3_DATA:
  1017.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  1018.         k = elcont.eldata->qmd3.dim.size_x * elcont.eldata->qmd3.dim.size_y;
  1019.         for (j = 0; j < k; j++) 
  1020.         {
  1021.           switch (elcont.eldata->qmd3.vflag)
  1022.       {
  1023.             case PVERT_COORD:
  1024.               pt = elcont.eldata->qmd3.vdata.points[j];
  1025.               break;
  1026.  
  1027.             case PVERT_COORD_COLOUR:
  1028.               pt = elcont.eldata->qmd3.vdata.ptcolrs[j].point;
  1029.               break;
  1030.  
  1031.             case PVERT_COORD_NORMAL:
  1032.               pt = elcont.eldata->qmd3.vdata.ptnorms[j].point;
  1033.               break;
  1034.  
  1035.             case PVERT_COORD_COLOUR_NORMAL:
  1036.               pt = elcont.eldata->qmd3.vdata.ptconorms[j].point;
  1037.               break;
  1038.           }
  1039.           pt = ptk_transform3(compxform, &pt); 
  1040.           testpoint(&pt, bbox);
  1041.     }
  1042.         break;
  1043.  
  1044.       case PELEM_SET_OF_FILL_AREA_SET3_DATA:
  1045.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  1046.         for (j = 0; j < elcont.eldata->sofas3.vdata.num_vertices; j++) 
  1047.         {
  1048.           switch (elcont.eldata->sofas3.vflag)
  1049.       {
  1050.             case PVERT_COORD:
  1051.               pt = elcont.eldata->sofas3.vdata.vertex_data.points[j];
  1052.               break;
  1053.  
  1054.             case PVERT_COORD_COLOUR:
  1055.               pt = elcont.eldata->sofas3.vdata.vertex_data.ptcolrs[j].point;
  1056.               break;
  1057.  
  1058.             case PVERT_COORD_NORMAL:
  1059.               pt = elcont.eldata->sofas3.vdata.vertex_data.ptnorms[j].point;
  1060.               break;
  1061.  
  1062.             case PVERT_COORD_COLOUR_NORMAL:
  1063.               pt = elcont.eldata->sofas3.vdata.vertex_data.ptconorms[j].point;
  1064.               break;
  1065.           }
  1066.           pt = ptk_transform3(compxform, &pt); 
  1067.           testpoint(&pt, bbox);
  1068.     }
  1069.         break;
  1070.  
  1071.       case PELEM_NUNI_BSP_CURVE:
  1072.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  1073.         for (j = 0; j < elcont.eldata->nurb_curve.cpts.num_points; j++) 
  1074.         {
  1075.           switch (elcont.eldata->nurb_curve.rationality)
  1076.       {
  1077.             case PRATIONAL:
  1078.               pt = ptk_pt4topt3(&elcont.eldata->nurb_curve.cpts.points.point4d[j]);
  1079.               break;
  1080.  
  1081.             case PNON_RATIONAL:
  1082.               pt = elcont.eldata->nurb_curve.cpts.points.point3d[j];
  1083.               break;
  1084.           }
  1085.           pt = ptk_transform3(compxform, &pt);
  1086.       testpoint(&pt, bbox);
  1087.     }
  1088.         break;
  1089.  
  1090.       case PELEM_NUNI_BSP_SURF:
  1091.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  1092.         k = elcont.eldata->nurb_surf.grid.num_points.u_dim *
  1093.             elcont.eldata->nurb_surf.grid.num_points.v_dim;
  1094.         for (j = 0; j < k; j++) 
  1095.         {
  1096.           switch (elcont.eldata->nurb_surf.rationality)
  1097.       {
  1098.             case PRATIONAL:
  1099.               pt = ptk_pt4topt3(&elcont.eldata->nurb_surf.grid.points.point4d[j]);
  1100.               break;
  1101.  
  1102.             case PNON_RATIONAL:
  1103.               pt = elcont.eldata->nurb_surf.grid.points.point3d[j];
  1104.               break;
  1105.           }
  1106.           pt = ptk_transform3(compxform, &pt);
  1107.       testpoint(&pt, bbox);
  1108.     }
  1109.         break;
  1110.  
  1111.       case PELEM_CELL_ARRAY3_PLUS:
  1112.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, compxform);
  1113.         pt = ptk_transform3(compxform, 
  1114.                             &elcont.eldata->cell_array_plus.paral.p);
  1115.         testpoint(&pt, bbox);
  1116.         pt = ptk_transform3(compxform, 
  1117.                             &elcont.eldata->cell_array_plus.paral.q);
  1118.         testpoint(&pt, bbox);
  1119.         pt = ptk_transform3(compxform, 
  1120.                             &elcont.eldata->cell_array_plus.paral.r);
  1121.         testpoint(&pt, bbox);
  1122.         break;
  1123.  
  1124.       case PELEM_TEXT_COLR:
  1125.         tsl.tslplus.textcolour = elcont.eldata->colr;
  1126.         break;
  1127.  
  1128.       case PELEM_MARKER_COLR:
  1129.         tsl.tslplus.markercolour = elcont.eldata->colr;
  1130.         break;
  1131.  
  1132.       case PELEM_EDGE_COLR:
  1133.         tsl.tslplus.edgecolour = elcont.eldata->colr;
  1134.         break;
  1135.  
  1136.       case PELEM_LINE_COLR:
  1137.         tsl.tslplus.linecolour = elcont.eldata->colr;
  1138.         break;
  1139.  
  1140.       case PELEM_CURVE_APPROX_CRIT:
  1141.         tsl.tslplus.curveapproxtype = elcont.eldata->curv_approx.type;
  1142.         tsl.tslplus.curveapproxval = elcont.eldata->curv_approx.value;
  1143.         break;
  1144.  
  1145.       case PELEM_LINE_SHAD_METH:
  1146.         tsl.tslplus.lineshadmeth = elcont.eldata->int_data;
  1147.         break;
  1148.  
  1149.       case PELEM_INT_COLR:
  1150.         tsl.tslplus.intcolour = elcont.eldata->colr;
  1151.         break;
  1152.  
  1153.       case PELEM_BACK_INT_COLR:
  1154.         tsl.tslplus.backintcolour = elcont.eldata->colr;
  1155.         break;
  1156.  
  1157.       case PELEM_BACK_INT_STYLE:
  1158.         tsl.tslplus.backintstyle = elcont.eldata->int_style;
  1159.         break;
  1160.  
  1161.       case PELEM_BACK_INT_STYLE_IND:
  1162.         tsl.tslplus.backintstyleindex = elcont.eldata->int_data;
  1163.         break;
  1164.  
  1165.       case PELEM_REFL_PROPS:
  1166.         tsl.tslplus.reflprops = elcont.eldata->props;
  1167.         break;
  1168.  
  1169.       case PELEM_BACK_REFL_PROPS:
  1170.         tsl.tslplus.backreflprops = elcont.eldata->props;
  1171.         break;
  1172.  
  1173.       case PELEM_INT_SHAD_METH:
  1174.         tsl.tslplus.intshadmeth = elcont.eldata->int_data;
  1175.         break;
  1176.  
  1177.       case PELEM_BACK_INT_SHAD_METH:
  1178.         tsl.tslplus.backintshadmeth = elcont.eldata->int_data;
  1179.         break;
  1180.  
  1181.       case PELEM_INT_REFL_EQN:
  1182.         tsl.tslplus.reflmodel = elcont.eldata->int_data;
  1183.         break;
  1184.  
  1185.       case PELEM_BACK_INT_REFL_EQN:
  1186.         tsl.tslplus.backreflmodel = elcont.eldata->int_data;
  1187.         break;
  1188.  
  1189.       case PELEM_SURF_APPROX_CRIT:
  1190.         tsl.tslplus.surfapproxtype = elcont.eldata->surf_approx.type;
  1191.         tsl.tslplus.surfapproxuval = elcont.eldata->surf_approx.u_val;
  1192.         tsl.tslplus.surfapproxvval = elcont.eldata->surf_approx.v_val;
  1193.         break;
  1194.  
  1195.       case PELEM_PARA_SURF_CHARACS:
  1196.         tsl.tslplus.parasurftype = elcont.eldata->para_surf_characs.type;
  1197.         tsl.tslplus.parasurfdata = elcont.eldata->para_surf_characs.data;
  1198.         break;
  1199.  
  1200.       case PELEM_FACE_DISTING_MODE:
  1201.         tsl.tslplus.distingmode = elcont.eldata->disting_mode;
  1202.         break;
  1203.  
  1204.       case PELEM_FACE_CULL_MODE:
  1205.         tsl.tslplus.cullmode = elcont.eldata->cull_mode;
  1206.         break;
  1207.  
  1208.       case PELEM_LIGHT_SRC_STATE:
  1209.         addnameset(&elcont.eldata->lss.activation, 
  1210.                    &tsl.tslplus.lightsrcstate);
  1211.         removenameset(&elcont.eldata->lss.deactivation, 
  1212.                       &tsl.tslplus.lightsrcstate);
  1213.         break;
  1214.  
  1215.       case PELEM_DCUE_IND:
  1216.         tsl.tslplus.dcueindex = elcont.eldata->int_data;
  1217.         break;
  1218.  
  1219.       case PELEM_COLR_MAP_IND:
  1220.         tsl.tslplus.colourmapindex = elcont.eldata->int_data;
  1221.         break;
  1222.  
  1223.       case PELEM_RENDERING_COLR_MODEL:
  1224.         tsl.tslplus.renderingmodel = elcont.eldata->int_data;
  1225.         break;
  1226.  
  1227. #endif
  1228.       default:
  1229.         break; 
  1230.  
  1231.       }/* of case */
  1232.     }
  1233.     ptk_delstore(store);
  1234.     return result;
  1235. }  /* tsltraverseelement */
  1236.  
  1237. /*--------------------------------------------------------------------------*/
  1238.  
  1239. static void tsltraversepath(C(Pint *) sno, C(Pint) structid, 
  1240.                             C(Pelem_ref_list *) reflst)
  1241. PreANSI(Pint *sno)
  1242. PreANSI(Pint structid)
  1243. PreANSI(Pelem_ref_list *reflst)
  1244. /*
  1245. ** input params:
  1246. ** output params:
  1247. ** return value:
  1248. */
  1249. {
  1250.   Pint i, numelts, execid, err;
  1251.   ptkboolean finished;
  1252.  
  1253.   finished = FALSE;
  1254.   ptk_unitmatrix3(tsl.localtran);
  1255.   numelts = ptk_elemcount(structid);
  1256.  
  1257.   i = 1;
  1258.   do 
  1259.   {
  1260.     pset_elem_ptr(i);
  1261.     if ((*sno == reflst->num_elem_refs) && 
  1262.         (reflst->elem_refs[reflst->num_elem_refs-1].elem_pos == i-1))
  1263.       finished = TRUE;
  1264.     else
  1265.     if (tsltraverseelement(&execid, &boundbox))
  1266.     {
  1267.       if (((*sno < reflst->num_elem_refs) && 
  1268.            (reflst->elem_refs[*sno - 1].elem_pos == i) &&
  1269.            (reflst->elem_refs[*sno - 1].struct_id == structid)) ||
  1270.           ((*sno >= reflst->num_elem_refs) && 
  1271.            (reflst->elem_refs[reflst->num_elem_refs - 1].elem_pos < 0)))    
  1272.       {
  1273.         ptk_stacktsl();
  1274.         ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, tsl.globaltran);
  1275.         ptk_openstruct(execid);
  1276.         (*sno)++;
  1277.         tsltraversepath(sno, execid, reflst);
  1278.         ptk_closestruct();
  1279.         ptk_unstacktsl();
  1280.         pinq_elem_ptr(&err, &i);
  1281.       }
  1282.       else
  1283.       if (i < reflst->elem_refs[*sno - 1].elem_pos)
  1284.       {
  1285.         ptk_tsltraverserange(execid, 1, execid, -1, TRUE);
  1286.       }
  1287.     }
  1288.     i++;
  1289.   } while ((i <= numelts) && (!finished));
  1290. }  /* tsltraversepath */
  1291.  
  1292. /*--------------------------------------------------------------------------*/
  1293.  
  1294. static void tsltraverserange(C(Pint) startstid, C(Pint) startelemid,
  1295.                         C(Pint) stopstid, C(Pint) stopelemid, 
  1296.                         C(ptkboolean) descend)
  1297. PreANSI(Pint startstid)
  1298. PreANSI(Pint startelemid)
  1299. PreANSI(Pint stopstid)
  1300. PreANSI(Pint stopelemid)
  1301. PreANSI(ptkboolean descend)
  1302. /*
  1303. ** input params:
  1304. ** output params:
  1305. ** return value:
  1306. */
  1307. {
  1308.   Pint i, numelts, execid, err;
  1309.   ptkboolean finished;
  1310.  
  1311.   finished = FALSE;
  1312.   ptk_unitmatrix3(tsl.localtran);
  1313.   numelts = ptk_elemcount(startstid);
  1314.  
  1315.   i = startelemid;
  1316.   do 
  1317.   {
  1318.     pset_elem_ptr(i);
  1319.     if ((startstid == stopstid) && (i == stopelemid))
  1320.       finished = TRUE;
  1321.     if ((tsltraverseelement(&execid, &boundbox)) && (descend))
  1322.     {
  1323.       ptk_stacktsl();
  1324.       ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, tsl.globaltran);
  1325.       ptk_openstruct(execid);
  1326.       tsltraverserange(execid, 1, stopstid, stopelemid, descend);
  1327.       ptk_closestruct();
  1328.       ptk_unstacktsl();
  1329.       pinq_elem_ptr(&err, &i);
  1330.     }
  1331.     i++;
  1332.   } while ((i <= numelts) && (!finished));
  1333. }  /* tsltraverserange */
  1334.  
  1335. /*-------------------------------------------------------------------------*/
  1336.  
  1337. /*function:external*/
  1338. extern void ptk_stackbbox(C(void))
  1339. /* PreANSI() */
  1340. /*
  1341. ** \blurb{This function puts the current bounding box value on the
  1342. ** TSL bounding box stack.}
  1343. */
  1344. {
  1345.   ptkstslbox *boxitem;
  1346.  
  1347.   boxitem = (ptkstslbox *)malloc(sizeof(ptkstslbox));
  1348.   boxitem->next = tslbox;
  1349.   tslbox = boxitem;
  1350.   boxitem->box = boundbox;
  1351. }  /* ptk_stackbbox */
  1352.  
  1353. /*--------------------------------------------------------------------------*/
  1354.  
  1355. /*function:external*/
  1356. extern void ptk_unstackbbox(C(void))
  1357. /* PreANSI() */
  1358. /*
  1359. ** \blurb{This function gets the topmost bounding box value from the 
  1360. ** TSL bounding box stack.}
  1361. */
  1362. {
  1363.   ptkstslbox *boxitem;
  1364.  
  1365.   if (tslbox != NULL)
  1366.   {
  1367.     boundbox = tslbox->box;
  1368.     boxitem = tslbox->next;
  1369.     free(tslbox);
  1370.     tslbox = boxitem;
  1371.   }
  1372. }  /* ptk_unstackbbox */
  1373.  
  1374. /*--------------------------------------------------------------------------*/
  1375.  
  1376. /*function:external*/
  1377. extern void ptk_stacktsl(C(void))
  1378. /* PreANSI() */
  1379. /*
  1380. ** \blurb{This function puts the current TSL value on the TSL stack.}
  1381. */
  1382. {
  1383.   ptkstslstack *stackitem;
  1384.  
  1385.   stackitem = (ptkstslstack *)malloc(sizeof(ptkstslstack));
  1386.   stackitem->next = tslstack;
  1387.   tslstack = stackitem;
  1388.   stackitem->tsl = tsl;
  1389. }  /* ptk_stacktsl */
  1390.  
  1391. /*--------------------------------------------------------------------------*/
  1392.  
  1393. /*function:external*/
  1394. extern void ptk_unstacktsl(C(void))
  1395. /* PreANSI() */
  1396. /*
  1397. ** \blurb{This function gets the topmost TSL value from the TSL stack.}
  1398. */
  1399. {
  1400.   ptkstslstack *stackitem;
  1401.  
  1402.   if (tslstack != NULL)
  1403.   {
  1404.     tsl = tslstack->tsl;
  1405.     stackitem = tslstack->next;
  1406.     free(tslstack);
  1407.     tslstack = stackitem;
  1408.   }
  1409. }  /* ptk_unstacktsl */
  1410.  
  1411. /*--------------------------------------------------------------------------*/
  1412.  
  1413. /*function:external*/
  1414. extern ptkboolean ptk_boundingbox(C(Pint) structid, C(Plimit3 *) wcbounds, 
  1415.                                C(ptkboolean) descend)
  1416. PreANSI(Pint structid)
  1417. PreANSI(Plimit3 *wcbounds)
  1418. PreANSI(ptkboolean descend)
  1419. /*
  1420. ** \parambegin
  1421. ** \param{Pint}{structid}{structure network identifier}{IN}
  1422. ** \param{Plimit3 *}{wcbounds}{bounding box in world coordinates}{OUT}
  1423. ** \param{ptkboolean}{descend}{flag to indicate traversal}{IN}
  1424. ** \paramend
  1425. ** \blurb{This function evaluates the bounding box for a structure or
  1426. ** structure network. If {\tt descend} 
  1427. ** is set to TRUE then the bounding box for the complete structure
  1428. ** network is returned, otherwise just for a single structure.
  1429. ** The function returns TRUE if the resulting bounding box is valid, 
  1430. ** otherwise FALSE. A structure with no output primitives returns an
  1431. ** invalid bounding box.}
  1432. */
  1433. {
  1434.   ptk_stacktsl();  
  1435.   ptk_stackbbox();
  1436.   ptk_inittsl();
  1437.   ptk_openstruct(structid);
  1438.   tsltraverserange(structid, 1, structid, -1, descend);
  1439.   *wcbounds = boundbox;
  1440.   ptk_closestruct();
  1441.   ptk_unstackbbox();
  1442.   ptk_unstacktsl();
  1443.  
  1444.   if (wcbounds->x_min == 1000.0)
  1445.   {
  1446.     *wcbounds = ptk_limit3(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
  1447.     return FALSE;
  1448.   }
  1449.   else
  1450.     return TRUE;
  1451. }  /* ptk_boundingbox */
  1452.  
  1453. /*--------------------------------------------------------------------------*/
  1454.  
  1455. /*function:external*/
  1456. extern void ptk_inittsl(C(void))
  1457. /* PreANSI() */
  1458. /*
  1459. ** \blurb{This function initialises the current TSL values to the
  1460. ** default values from the PHIGS description table.
  1461. ** The default ASF value for each attribute is assumed to be INDIVIDUAL.}
  1462. */
  1463. {
  1464.   /* polyline */
  1465.   tsl.lnattr.ind = 1;
  1466.   tsl.lnattr.bundle.type = 1;
  1467.   tsl.lnattr.bundle.width = 1.0;
  1468.   tsl.lnattr.bundle.colr_ind = 1;
  1469.   tsl.lnattr.type_asf = PASF_INDIV;
  1470.   tsl.lnattr.width_asf = PASF_INDIV;
  1471.   tsl.lnattr.colr_ind_asf = PASF_INDIV;
  1472.   /* marker */
  1473.   tsl.mkattr.ind = 1;
  1474.   tsl.mkattr.bundle.type = 3;
  1475.   tsl.mkattr.bundle.size = 1.0;
  1476.   tsl.mkattr.bundle.colr_ind = 1;
  1477.   tsl.mkattr.type_asf = PASF_INDIV;
  1478.   tsl.mkattr.size_asf = PASF_INDIV;
  1479.   tsl.mkattr.colr_ind_asf = PASF_INDIV;
  1480.   /* interior */
  1481.   tsl.interattr.ind = 1;
  1482.   tsl.interattr.bundle.style = PSTYLE_HOLLOW;
  1483.   tsl.interattr.bundle.style_ind = 1;
  1484.   tsl.interattr.bundle.colr_ind = 1;
  1485.   tsl.interattr.style_asf = PASF_INDIV;
  1486.   tsl.interattr.style_ind_asf = PASF_INDIV;
  1487.   tsl.interattr.colr_ind_asf = PASF_INDIV;
  1488.   /* edge */
  1489.   tsl.edgeattr.ind = 1;
  1490.   tsl.edgeattr.bundle.flag = PEDGE_OFF;
  1491.   tsl.edgeattr.bundle.type = 1;
  1492.   tsl.edgeattr.bundle.width = 1.0;
  1493.   tsl.edgeattr.bundle.colr_ind = 1;
  1494.   tsl.edgeattr.flag_asf = PASF_INDIV;
  1495.   tsl.edgeattr.width_asf = PASF_INDIV;
  1496.   tsl.edgeattr.colr_ind_asf = PASF_INDIV;
  1497.   tsl.edgeattr.type_asf = PASF_INDIV;
  1498.   /* text */
  1499.   tsl.txbundl.font = 1;
  1500.   tsl.txbundl.prec = PPREC_STRING;
  1501.   tsl.txbundl.char_expan = 1.0;
  1502.   tsl.txbundl.char_space = 0.0;
  1503.   tsl.txbundl.colr_ind = 1;
  1504.   tsl.textindex = 1;
  1505.   tsl.textfontasf = PASF_INDIV;
  1506.   tsl.textprecasf = PASF_INDIV;
  1507.   tsl.charexpanasf = PASF_INDIV;
  1508.   tsl.charspaceasf = PASF_INDIV;
  1509.   tsl.textcolourasf = PASF_INDIV;
  1510.   tsl.charheight = 0.01;
  1511.   tsl.charup= ptk_point(0.0, 1.0);
  1512.   tsl.textpath = PPATH_RIGHT;
  1513.   tsl.textalign.hor = PHOR_NORM;
  1514.   tsl.textalign.vert = PVERT_NORM;
  1515.   tsl.annocharheight = 0.01;
  1516.   tsl.annocharup = ptk_point(0.0, 1.0);
  1517.   tsl.annotextpath = PPATH_RIGHT;
  1518.   tsl.annotextalign.hor = PHOR_NORM;
  1519.   tsl.annotextalign.vert = PVERT_NORM;
  1520.   tsl.annostyle = 1;
  1521.   /* pattern */
  1522.   tsl.patsize.size_x = 1.0;
  1523.   tsl.patsize.size_y = 1.0;
  1524.   tsl.patrefpt = ptk_point3(0.0, 0.0, 0.0);
  1525.   tsl.patvec[0] = ptk_point3(1.0, 0.0, 0.0);
  1526.   tsl.patvec[1] = ptk_point3(0.0, 1.0, 0.0);
  1527.   /* pick identifier */
  1528.   tsl.pickid = 0;
  1529.   /* view index */
  1530.   tsl.viewindex = 0;
  1531.   /* HLHSR identifier */
  1532.   tsl.hlhsrid = 0;
  1533.   /* name set */
  1534.   tsl.nameset.num_ints = 0;
  1535.   tsl.nameset.ints = tsl.names;
  1536.   /* global modelling transformation */
  1537.   ptk_unitmatrix3(tsl.globaltran);
  1538.   /* local modelling transformation */
  1539.   ptk_unitmatrix3(tsl.localtran);
  1540.   /* modelling clip */
  1541.   /* Implementation dependent - HP doesn't support
  1542.   ** modelling clip.
  1543.   */
  1544. #ifdef SUN
  1545.   tsl.modelclipoperator = PMC_REPLACE;
  1546. #endif
  1547. #ifdef PEXSI
  1548.   tsl.modelclipoperator = PMC_REPLACE;
  1549. #endif
  1550. #ifdef HP
  1551.   tsl.modelclipoperator = 0;
  1552. #endif
  1553.   tsl.modelclipvolume.num_half_spaces = 0;
  1554.   tsl.modelclipindicator = PIND_NO_CLIP;
  1555.   boundbox = ptk_limit3(1000.0, -1000.0, 1000.0, -1000.0, 1000.0, -1000.0);
  1556. #ifdef SUN
  1557.   tsl.tslplus.datamapindex = 1;
  1558.   tsl.tslplus.backintindex = 1;
  1559.   tsl.tslplus.backdatamapindex = 1;
  1560.   tsl.tslplus.reflindex = 1;
  1561.   tsl.tslplus.backreflindex = 1;
  1562.   tsl.tslplus.paramsurfindex = 1;
  1563.   tsl.tslplus.linecolour.type = PINDIRECT;
  1564.   tsl.tslplus.linecolour.val.ind = 1;
  1565.   tsl.tslplus.lineshadmeth = 1;
  1566.   tsl.tslplus.linecolourasf = PASF_INDIV;
  1567.   tsl.tslplus.lineshadmethasf = PASF_INDIV;
  1568.   tsl.tslplus.markercolour.type = PINDIRECT;
  1569.   tsl.tslplus.markercolour.val.ind = 1;
  1570.   tsl.tslplus.markercolourasf = PASF_INDIV;
  1571.   tsl.tslplus.textcolour.type = PINDIRECT;
  1572.   tsl.tslplus.textcolour.val.ind = 1;
  1573.   tsl.tslplus.textcolourasf = PASF_INDIV;
  1574.   tsl.tslplus.distingmode = PDISTING_NO;
  1575.   tsl.tslplus.cullmode = PCULL_NONE;
  1576.   tsl.tslplus.intcolour.type = PINDIRECT;
  1577.   tsl.tslplus.intcolour.val.ind = 1;
  1578.   tsl.tslplus.intshadmeth = 1;
  1579.   tsl.tslplus.datamapmeth = 1;
  1580.   tsl.tslplus.reflprops.ambient_coef = 1.0;
  1581.   tsl.tslplus.reflprops.diffuse_coef = 1.0;
  1582.   tsl.tslplus.reflprops.specular_coef = 1.0;
  1583.   tsl.tslplus.reflprops.specular_colr.type = 1;
  1584.   tsl.tslplus.reflprops.specular_colr.val.general.x = 1.0;
  1585.   tsl.tslplus.reflprops.specular_colr.val.general.y = 1.0;
  1586.   tsl.tslplus.reflprops.specular_colr.val.general.z = 1.0;
  1587.   tsl.tslplus.reflprops.specular_exp = 0.0;
  1588.   tsl.tslplus.reflprops.transpar_coef = 1.0;
  1589.   tsl.tslplus.reflmodel = 1;
  1590.   tsl.tslplus.intcolourasf = PASF_INDIV;
  1591.   tsl.tslplus.intshadmethasf = PASF_INDIV;
  1592.   tsl.tslplus.datamapmethasf = PASF_INDIV;
  1593.   tsl.tslplus.reflpropsasf = PASF_INDIV;
  1594.   tsl.tslplus.reflmodelasf = PASF_INDIV;
  1595.   tsl.tslplus.backintstyle = PSTYLE_HOLLOW;
  1596.   tsl.tslplus.backintcolour.type = PINDIRECT;
  1597.   tsl.tslplus.backintcolour.val.ind = 1;
  1598.   tsl.tslplus.backintshadmeth = 1;
  1599.   tsl.tslplus.backdatamapmeth = 1;
  1600.   tsl.tslplus.backreflprops.ambient_coef = 1.0;
  1601.   tsl.tslplus.backreflprops.diffuse_coef = 1.0;
  1602.   tsl.tslplus.backreflprops.specular_coef = 1.0;
  1603.   tsl.tslplus.backreflprops.specular_colr.type = 1;
  1604.   tsl.tslplus.backreflprops.specular_colr.val.general.x = 1.0;
  1605.   tsl.tslplus.backreflprops.specular_colr.val.general.y = 1.0;
  1606.   tsl.tslplus.backreflprops.specular_colr.val.general.z = 1.0;
  1607.   tsl.tslplus.backreflprops.specular_exp = 0.0;
  1608.   tsl.tslplus.backreflprops.transpar_coef = 1.0;
  1609.   tsl.tslplus.backreflmodel = 1;
  1610.   tsl.tslplus.backintstyleasf = PASF_INDIV;
  1611.   tsl.tslplus.backintstyleindexasf = PASF_INDIV;
  1612.   tsl.tslplus.backintcolourasf = PASF_INDIV;
  1613.   tsl.tslplus.backintshadmethasf = PASF_INDIV;
  1614.   tsl.tslplus.backdatamapmethasf = PASF_INDIV;
  1615.   tsl.tslplus.backreflpropsasf = PASF_INDIV;
  1616.   tsl.tslplus.backreflmodelasf = PASF_INDIV;
  1617.   tsl.tslplus.lightsrcstate.num_ints = 0;
  1618.   tsl.tslplus.lightsrcstate.ints = tsl.tslplus.lights;
  1619.   tsl.tslplus.edgecolour.type = PINDIRECT;
  1620.   tsl.tslplus.edgecolour.val.ind = 1;
  1621.   tsl.tslplus.edgecolourasf = PASF_INDIV;
  1622.   tsl.tslplus.curveapproxtype = 1;
  1623.   tsl.tslplus.curveapproxval = 1.0;
  1624.   tsl.tslplus.curveapproxasf = PASF_INDIV;
  1625.   tsl.tslplus.surfapproxtype = 1;
  1626.   tsl.tslplus.surfapproxuval = 1.0;
  1627.   tsl.tslplus.surfapproxvval = 1.0;
  1628.   tsl.tslplus.surfapproxval = PASF_INDIV;
  1629.   tsl.tslplus.parasurftype = 1;
  1630.   tsl.tslplus.parasurfasf = PASF_INDIV;
  1631.   tsl.tslplus.renderingmodel = 0;
  1632.   tsl.tslplus.dcueindex = 1;
  1633.   tsl.tslplus.colourmapindex = 1;
  1634. #endif
  1635. }  /* ptk_inittsl */
  1636.  
  1637. /*--------------------------------------------------------------------------*/
  1638.  
  1639. /*function:external*/
  1640. extern void ptk_initbbox(C(void))
  1641. /* PreANSI() */
  1642. /*
  1643. ** \blurb{This function initialises the current TSL bounding box value
  1644. ** to be (1000.0, -1000.0, 1000.0, -1000.0, 1000.0, -1000.0). This enables
  1645. ** the real bounding box to be set when an output primitive is reached.}
  1646. */
  1647. {
  1648.   boundbox = ptk_limit3(1000.0, -1000.0, 1000.0, -1000.0, 1000.0, -1000.0);
  1649. }  /* ptk_initbbox */
  1650.  
  1651. /*--------------------------------------------------------------------------*/
  1652.  
  1653. /*function:external*/
  1654. extern void ptk_tsltraversepath(C(Pelem_ref_list *) reflst)
  1655. PreANSI(Pelem_ref_list *reflst)
  1656. /*
  1657. ** \parambegin
  1658. ** \param{Pelem\_ref\_list *}{reflst}{structure-element path}{IN}
  1659. ** \paramend
  1660. ** \blurb{This function makes TSL traverse a structure path
  1661. ** and updates the current TSL values appropriately.}
  1662. */
  1663. {
  1664.   Pint stid, sno;
  1665.   Plimit3 bbox;
  1666.  
  1667.   ptk_stacktsl();
  1668.   stid = reflst->elem_refs[0].struct_id;
  1669.   ptk_openstruct(stid);
  1670.   sno = 1;
  1671.   tsltraversepath(&sno, stid, reflst);
  1672.   ptk_closestruct();
  1673. }  /* ptk_tsltraversepath */
  1674.  
  1675. /*--------------------------------------------------------------------------*/
  1676.  
  1677. /*function:external*/
  1678. extern void ptk_tsltraverserange(C(Pint) startstid, C(Pint) startelemid,
  1679.                      C(Pint) stopstid, C(Pint) stopelemid, C(ptkboolean) descend)
  1680. PreANSI(Pint startstid)
  1681. PreANSI(Pint startelemid)
  1682. PreANSI(Pint stopstid)
  1683. PreANSI(Pint stopelemid)
  1684. PreANSI(ptkboolean descend)
  1685. /*
  1686. ** \parambegin
  1687. ** \param{Pint}{startstid}{start structure identifier}{IN}
  1688. ** \param{Pint}{startelemid}{start element number}{IN}
  1689. ** \param{Pint}{stopstid}{stop structure identifier}{IN}
  1690. ** \param{Pint}{stopelemid}{stop element number}{IN}
  1691. ** \param{ptkboolean}{descend}{flag to indicate traversal}{IN}
  1692. ** \paramend
  1693. ** \blurb{This function makes TSL traverse between two points in a structure
  1694. ** network. If {\tt descend} is set to TRUE then any
  1695. ** EXECUTE STRUCTURE elements which occur between the two points
  1696. ** are followed, otherwise they are ignored.}
  1697. */
  1698. {
  1699.   ptk_openstruct(startstid);
  1700.   tsltraverserange(startstid, startelemid, stopstid, stopelemid, descend);
  1701.   ptk_closestruct();
  1702. }  /* ptk_tsltraverserange */
  1703.  
  1704. /*--------------------------------------------------------------------------*/
  1705.  
  1706. /*function:external*/
  1707. extern void ptk_settslstart(C(Pint) startstid, C(Pint) startelemid)
  1708. PreANSI(Pint startstid)
  1709. PreANSI(Pint startelemid)
  1710. /*
  1711. ** \parambegin
  1712. ** \param{Pint}{startstid}{start structure identifier}{IN}
  1713. ** \param{Pint}{startelemid}{start element number}{IN}
  1714. ** \paramend
  1715. ** \blurb{This function sets the TSL traversal to start at a certain point
  1716. ** in a structure network. This structure is referred to as the TSL structure
  1717. ** network.}
  1718. */
  1719. {
  1720.   ptk_inittsl();
  1721.   curstid = firststid = startstid;
  1722.   curelemid = firstelemid = startelemid;
  1723. }  /* ptk_settslstart */
  1724.  
  1725. /*--------------------------------------------------------------------------*/
  1726.  
  1727. /*function:external*/
  1728. extern void ptk_tsltraversenext(C(void))
  1729. /* PreANSI() */
  1730. /*
  1731. ** \blurb{This function makes TSL traverse the next element in the current
  1732. ** TSL structure network. If it is an EXECUTE STRUCTURE element
  1733. ** TSL will follow the execute path.}
  1734. */
  1735. {
  1736.   Pint i, numelts, execid, err;
  1737.  
  1738.   numelts = ptk_elemcount(curstid);
  1739.   if (curelemid > numelts)
  1740.   {
  1741.     if (curstid == firststid)
  1742.     {
  1743.       ptk_inittsl();
  1744.       curelemid = firstelemid;
  1745.     }
  1746.     else
  1747.     {
  1748.       do
  1749.       {
  1750.         ptk_unstacktsl();
  1751.         unstackpos();
  1752.       } while ((curelemid > ptk_elemcount(curstid)) && (tslpos != NULL));
  1753.     }
  1754.   } 
  1755.   ptk_openstruct(curstid);
  1756.   pset_elem_ptr(curelemid);
  1757.   curelemid++;
  1758.   if (tsltraverseelement(&execid, &boundbox))
  1759.   {
  1760.     ptk_stacktsl();
  1761.     stackpos();
  1762.     curstid = execid;
  1763.     curelemid = 1;
  1764.     ptk_multiplymatrix3(tsl.globaltran, tsl.localtran, tsl.globaltran);
  1765.     ptk_unitmatrix3(tsl.localtran);
  1766.   }
  1767.   ptk_closestruct();
  1768. }  /* ptk_tsltraversenext */
  1769.  
  1770. /*--------------------------------------------------------------------------*/
  1771.  
  1772. /*function:external*/
  1773. extern void ptk_tsltraversetoend(C(void))
  1774. /* PreANSI() */
  1775. /*
  1776. ** \blurb{This function makes TSL traverse to the end of the TSL structure 
  1777. ** network.}
  1778. */
  1779. {
  1780.   while ((curstid != firststid) && (curelemid != firstelemid))
  1781.     ptk_tsltraversenext();
  1782. }  /* ptk_tsltraversetoend */
  1783.  
  1784. /*--------------------------------------------------------------------------*/
  1785.  
  1786. /*function:external*/
  1787. extern void ptk_inqboundingbox(C(Plimit3 *) bbox)
  1788. PreANSI(Plimit3 *bbox)
  1789. /*
  1790. ** \parambegin
  1791. ** \param{Plimit3 *}{bbox}{bounding box (WC)}{OUT}
  1792. ** \paramend
  1793. ** \blurb{This function may be used to obtain current TSL bounding box
  1794. ** value. This is the bounding box of the TSL structure network at the
  1795. ** current point of traversal.}
  1796. */
  1797. {
  1798.   *bbox = boundbox;
  1799. }  /* ptk_inqboundingbox */
  1800.  
  1801. /*--------------------------------------------------------------------------*/
  1802.  
  1803. /*function:external*/
  1804. extern void ptk_inqtsledge(C(Pint *) edgeind, C(Pedge_flag *) edgeflag, 
  1805.            C(Pint *) edgetype, C(Pfloat *) edgewidth, C(Pint *) edgecolour)
  1806. PreANSI(Pint *edgeind)
  1807. PreANSI(Pedge_flag *edgeflag)
  1808. PreANSI(Pint *edgetype)
  1809. PreANSI(Pfloat *edgewidth)
  1810. PreANSI(Pint *edgecolour)
  1811. /*
  1812. ** \parambegin
  1813. ** \param{Pint *}{edgeind}{edge index}{OUT}
  1814. ** \param{Pedge\_flag *}{edgeflag}{edge flag}{OUT}
  1815. ** \param{Pint *}{edgetype}{edge type}{OUT}
  1816. ** \param{Pfloat *}{edgewidth}{edge width}{OUT}
  1817. ** \param{Pint *}{edgecolour}{edge colour}{OUT}
  1818. ** \paramend
  1819. ** \blurb{This function may be used to obtain the current TSL 
  1820. ** edge attributes.}
  1821. */
  1822. {
  1823.   *edgeind = tsl.edgeattr.ind;
  1824.   *edgeflag = tsl.edgeattr.bundle.flag;
  1825.   *edgetype = tsl.edgeattr.bundle.type;
  1826.   *edgewidth = tsl.edgeattr.bundle.width;
  1827.   *edgecolour = tsl.edgeattr.bundle.colr_ind;
  1828. }  /* ptk_inqtsledge */
  1829.  
  1830. /*--------------------------------------------------------------------------*/
  1831.  
  1832. /*function:external*/
  1833. extern void ptk_inqtslline(C(Pint *) lineind, C(Pint *) linetype, 
  1834.                            C(Pfloat *) linewidth, C(Pint *) linecolour)
  1835. PreANSI(Pint *lineind)
  1836. PreANSI(Pint *linetype)
  1837. PreANSI(Pfloat *linewidth)
  1838. PreANSI(Pint *linecolour)
  1839. /*
  1840. ** \parambegin
  1841. ** \param{Pint *}{lineind}{line index}{OUT}
  1842. ** \param{Pint *}{linetype}{line type}{OUT}
  1843. ** \param{Pfloat *}{linewidth}{line width}{OUT}
  1844. ** \param{Pint *}{linecolour}{line colour}{OUT}
  1845. ** \paramend
  1846. ** \blurb{This function may be used to obtain the current TSL line 
  1847. ** attributes.}
  1848. */
  1849. {
  1850.   *lineind = tsl.lnattr.ind;
  1851.   *linetype = tsl.lnattr.bundle.type;
  1852.   *linewidth = tsl.lnattr.bundle.width;
  1853.   *linecolour = tsl.lnattr.bundle.colr_ind;
  1854. }  /* ptk_inqtslline */
  1855.  
  1856. /*--------------------------------------------------------------------------*/
  1857.  
  1858. /*function:external*/
  1859. extern void ptk_inqtslmarker(C(Pint *) markerind, C(Pint *) markertype, 
  1860.                            C(Pfloat *) markersize, C(Pint *) markercolour)
  1861. PreANSI(Pint *markerind)
  1862. PreANSI(Pint *markertype)
  1863. PreANSI(Pfloat *markersize)
  1864. PreANSI(Pint *markercolour)
  1865. /*
  1866. ** \parambegin
  1867. ** \param{Pint *}{markerind}{marker index}{OUT}
  1868. ** \param{Pint *}{markertype}{marker type}{OUT}
  1869. ** \param{Pfloat *}{markersize}{marker size}{OUT}
  1870. ** \param{Pint *}{markercolour}{marker colour}{OUT}
  1871. ** \paramend
  1872. ** \blurb{This function may be used to obtain the current TSL marker 
  1873. ** attributes.}
  1874. */
  1875. {
  1876.   *markerind = tsl.mkattr.ind;
  1877.   *markertype = tsl.mkattr.bundle.type;
  1878.   *markersize = tsl.mkattr.bundle.size;
  1879.   *markercolour = tsl.mkattr.bundle.colr_ind;
  1880. }  /* ptk_inqtslmarker */
  1881.  
  1882. /*--------------------------------------------------------------------------*/
  1883.  
  1884. /*function:external*/
  1885. extern void ptk_inqtslinterior(C(Pint *) intind, C(Pint *) intstyle, 
  1886.                            C(Pint *) intstyleind, C(Pint *) intcolour)
  1887. PreANSI(Pint *intind)
  1888. PreANSI(Pint *intstyle)
  1889. PreANSI(Pint *intstyleind)
  1890. PreANSI(Pint *intcolour)
  1891. /*
  1892. ** \parambegin
  1893. ** \param{Pint *}{intind}{interior index}{OUT}
  1894. ** \param{Pint *}{intstyle}{interior style}{OUT}
  1895. ** \param{Pfloat *}{intstyleind}{interior style index}{OUT}
  1896. ** \param{Pint *}{intcolour}{interior colour}{OUT}
  1897. ** \paramend
  1898. ** \blurb{This function may be used to obtain the current TSL interior 
  1899. ** attributes.}
  1900. */
  1901. {
  1902.   *intind = tsl.interattr.ind;
  1903.   *intstyle = tsl.interattr.bundle.style;
  1904.   *intstyleind = tsl.interattr.bundle.style_ind;
  1905.   *intcolour = tsl.interattr.bundle.colr_ind;
  1906. }  /* ptk_inqtslint */
  1907.  
  1908. /*--------------------------------------------------------------------------*/
  1909.  
  1910. /*function:external*/
  1911. extern void ptk_inqtsltext(C(Pint *) textind, C(Pint *) textfont, 
  1912.                            C(Ptext_prec *) textprec, C(Ptext_path *) textpath, 
  1913.                            C(Ptext_align *) textalign, C(Pint *) textcolour)
  1914. PreANSI(Pint *textind)
  1915. PreANSI(Pint *textfont)
  1916. PreANSI(Ptext_prec *textprec)
  1917. PreANSI(Ptext_path *textpath)
  1918. PreANSI(Ptext_align *textalign)
  1919. PreANSI(Pint *textcolour)
  1920. /*
  1921. ** \parambegin
  1922. ** \param{Pint *}{textind}{text index}{OUT}
  1923. ** \param{Pint *}{textfont}{text font}{OUT}
  1924. ** \param{Ptext\_prec *}{textprec}{text precision}{OUT}
  1925. ** \param{Ptext\_path *}{textpath}{text path}{OUT}
  1926. ** \param{Ptext\_align *}{textalign}{text alignment}{OUT}
  1927. ** \param{Pint *}{textcolour}{text colour}{OUT}
  1928. ** \paramend
  1929. ** \blurb{This function may be used to obtain the current TSL text 
  1930. ** attributes.}
  1931. */
  1932. {
  1933.   *textind = tsl.textindex;
  1934.   *textfont = tsl.txbundl.font;
  1935.   *textprec = tsl.txbundl.prec;
  1936.   *textpath = tsl.textpath;
  1937.   *textalign = tsl.textalign;
  1938.   *textcolour = tsl.txbundl.colr_ind;
  1939. }  /* ptk_inqtsltext */
  1940.  
  1941. /*--------------------------------------------------------------------------*/
  1942.  
  1943. /*function:external*/
  1944. extern void ptk_inqtslannotext(C(Pint *) style, C(Pfloat *) charheight, 
  1945.                            C(Ppoint *) charup, C(Ptext_align *) textalign, 
  1946.                            C(Ptext_path *) textpath)
  1947. PreANSI(Pint *style)
  1948. PreANSI(Pfloat *charheight)
  1949. PreANSI(Ppoint *charup)
  1950. PreANSI(Ptext_path *textpath)
  1951. PreANSI(Ptext_align *textalign)
  1952. /*
  1953. ** \parambegin
  1954. ** \param{Pint *}{style}{annotation style}{OUT}
  1955. ** \param{Pfloat *}{charheight}{annotation character height}{OUT}
  1956. ** \param{Ppoint *}{charup}{annotation character up vector}{OUT}
  1957. ** \param{Ptext\_align *}{textalign}{annotation text alignment}{OUT}
  1958. ** \param{Ptext\_path *}{textpath}{annotation text path}{OUT}
  1959. ** \paramend
  1960. ** \blurb{This function may be used to obtain the current TSL
  1961. ** annotation text attributes.}
  1962. */
  1963. {
  1964.   *style = tsl.annostyle;
  1965.   *charheight = tsl.annocharheight;
  1966.   *charup = tsl.annocharup;
  1967.   *textalign = tsl.annotextalign;
  1968.   *textpath = tsl.annotextpath;
  1969. }  /* ptk_inqtslannotext */
  1970.  
  1971. /*--------------------------------------------------------------------------*/
  1972.  
  1973. /*function:external*/
  1974. extern void ptk_inqtslchar(C(Pfloat *) exp, C(Pfloat *) spacing, 
  1975.                            C(Pfloat *) height, C(Ppoint *) charup)
  1976. PreANSI(Pfloat *exp)
  1977. PreANSI(Pfloat *spacing)
  1978. PreANSI(Pfloat *height)
  1979. PreANSI(Ppoint *charup)
  1980. /*
  1981. ** \parambegin
  1982. ** \param{Pfloat *}{exp}{character expansion factor}{OUT}
  1983. ** \param{Pfloat *}{spacing}{character spacing}{OUT}
  1984. ** \param{Pfloat *}{height}{character height}{OUT}
  1985. ** \param{Ppoint *}{charup}{character up vector}{OUT}
  1986. ** \paramend
  1987. ** \blurb{This function may be used to obtain the current TSL character 
  1988. ** attributes.}
  1989. */
  1990. {
  1991.   *exp = tsl.txbundl.char_expan;
  1992.   *spacing = tsl.txbundl.char_space;
  1993.   *height = tsl.charheight;
  1994.   *charup = tsl.charup;
  1995. }  /* ptk_inqtslannotext */
  1996.  
  1997. /*--------------------------------------------------------------------------*/
  1998.  
  1999. /*function:external*/
  2000. extern void ptk_inqtslctm(C(Pmatrix3) globaltran, C(Pmatrix3) localtran) 
  2001. PreANSI(Pmatrix3 globaltran)
  2002. PreANSI(Pmatrix3 localtran)
  2003. /*
  2004. ** \parambegin
  2005. ** \param{Pmatrix3}{globaltran}{global transformation matrix}{OUT}
  2006. ** \param{Pmatrix3}{localtran}{local transformation matrix}{OUT}
  2007. ** \paramend
  2008. ** \blurb{This function may be used to obtain the current TSL transformation 
  2009. ** matrices.}
  2010. */
  2011. {
  2012.   memcpy(globaltran, tsl.globaltran, sizeof(Pmatrix3));
  2013.   memcpy(localtran, tsl.localtran, sizeof(Pmatrix3));
  2014. }  /* ptk_inqtslctm */
  2015.  
  2016. /*--------------------------------------------------------------------------*/
  2017.  
  2018. /*function:external*/
  2019. extern void ptk_inqtslnameset(C(Pint) size, C(Pint_list *) nameset, 
  2020.                               C(Pint *) totalsize) 
  2021. PreANSI(Pint size)
  2022. PreANSI(Pint_list *nameset)
  2023. PreANSI(Pint *totalsize)
  2024. /*
  2025. ** \parambegin
  2026. ** \param{Pint}{size}{length of nameset integer list}{IN}
  2027. ** \param{Pint\_list *}{nameset}{current nameset}{OUT}
  2028. ** \param{Pint *}{totalsize}{actual length of nameset integer list}{OUT}
  2029. ** \paramend
  2030. ** \blurb{This function may be used to obtain the current TSL nameset.}
  2031. */
  2032. {
  2033.   Pint i;
  2034.  
  2035.   if (size >= tsl.nameset.num_ints)
  2036.     for (i = 0; i < tsl.nameset.num_ints; i++)
  2037.       nameset->ints[i] = tsl.nameset.ints[i];
  2038.   *totalsize = tsl.nameset.num_ints;
  2039. }  /* ptk_inqtslnameset */
  2040.  
  2041. /*--------------------------------------------------------------------------*/
  2042.  
  2043. /*function:external*/
  2044. extern void ptk_inqtslids(C(Pint *) pickid, C(Pint *) hlhsrid, 
  2045.                           C(Pint *) viewind) 
  2046. PreANSI(Pint *pickid)
  2047. PreANSI(Pint *hlhsrid)
  2048. PreANSI(Pint *viewind)
  2049. /*
  2050. ** \parambegin
  2051. ** \param{Pint *}{pickid}{pick identifier}{OUT}
  2052. ** \param{Pint *}{hlhsrid}{HLHSR identifier}{OUT}
  2053. ** \param{Pint *}{viewind}{view index}{OUT}
  2054. ** \paramend
  2055. ** \blurb{This function may be used to obtain the current TSL values
  2056. ** for pick identifier, HLHSR identifier and view index.}
  2057. */
  2058. {
  2059.   *pickid = tsl.pickid;
  2060.   *hlhsrid = tsl.hlhsrid;
  2061.   *viewind = tsl.viewindex;
  2062. }  /* ptk_inqtslids */
  2063.  
  2064. /*--------------------------------------------------------------------------*/
  2065.  
  2066. /*function:external*/
  2067. extern void ptk_inqtslpattern(C(Pfloat_size *) size, C(Ppoint3 *) refpt, 
  2068.                           C(Ppoint3 *) refvec) 
  2069. PreANSI(Pfloat_size *size)
  2070. PreANSI(Ppoint3 *refpt)
  2071. PreANSI(Ppoint3 refvec[2])
  2072. /*
  2073. ** \parambegin
  2074. ** \param{Pfloat\_size *}{size}{pattern size}{OUT}
  2075. ** \param{Ppoint3 *}{refpt}{pattern reference point}{OUT}
  2076. ** \param{Ppoint3 *}{refvec}{pattern reference vectors}{OUT}
  2077. ** \paramend
  2078. ** \blurb{This function may be used to obtain the current TSL pattern 
  2079. ** attributes.}
  2080. */
  2081. {
  2082.   *size = tsl.patsize;
  2083.   *refpt = tsl.patrefpt;
  2084.   refvec[0] = tsl.patvec[0];
  2085.   refvec[1] = tsl.patvec[1];
  2086. }  /* ptk_inqtslpattern */
  2087.  
  2088. /*--------------------------------------------------------------------------*/
  2089.  
  2090. /*function:external*/
  2091. extern void ptk_inqtslattrasf(C(Paspect) attr, C(Pasf *) asf) 
  2092. PreANSI(Paspect attr)
  2093. PreANSI(Pasf *asf)
  2094. /*
  2095. ** \parambegin
  2096. ** \param{Paspect}{attr}{attribute type}{IN}
  2097. ** \param{Pasf *}{asf}{attribute aspect source flag}{OUT}
  2098. ** \paramend
  2099. ** \blurb{This function may be used to obtain the current TSL 
  2100. ** aspect source flag value for attribute type {\tt attr}.}
  2101. */
  2102. {
  2103.   switch (attr)
  2104.   {
  2105.     case PASPECT_LINETYPE: *asf = tsl.lnattr.type_asf;
  2106.       break;
  2107.  
  2108.     case PASPECT_LINEWIDTH: *asf = tsl.lnattr.width_asf;
  2109.       break;
  2110.  
  2111.     case PASPECT_LINE_COLR_IND: *asf = tsl.lnattr.colr_ind_asf;      
  2112.       break;
  2113.  
  2114.     case PASPECT_MARKER_TYPE: *asf = tsl.mkattr.type_asf;
  2115.       break;
  2116.  
  2117.     case PASPECT_MARKER_SIZE: 
  2118.       *asf = tsl.mkattr.size_asf;      
  2119.       break;
  2120.  
  2121.     case PASPECT_MARKER_COLR_IND: *asf = tsl.mkattr.colr_ind_asf;      
  2122.       break;
  2123.   
  2124.     case PASPECT_TEXT_FONT: *asf = tsl.textfontasf;
  2125.       break;
  2126.   
  2127.     case PASPECT_TEXT_PREC: *asf = tsl.textprecasf;      
  2128.       break;
  2129.   
  2130.     case PASPECT_CHAR_EXPAN: *asf = tsl.charexpanasf;      
  2131.       break;
  2132.   
  2133.     case PASPECT_CHAR_SPACE: *asf = tsl.charspaceasf;      
  2134.       break;
  2135.   
  2136.     case PASPECT_TEXT_COLR_IND: *asf = tsl.textcolourasf;
  2137.       break;
  2138.   
  2139.     case PASPECT_INT_STYLE: *asf = tsl.interattr.style_asf;
  2140.       break;
  2141.   
  2142.     case PASPECT_INT_STYLE_IND: *asf = tsl.interattr.style_ind_asf;
  2143.       break;
  2144.   
  2145.     case PASPECT_INT_COLR_IND: *asf = tsl.interattr.colr_ind_asf;
  2146.       break;
  2147.   
  2148.     case PASPECT_EDGE_FLAG: *asf = tsl.edgeattr.flag_asf;
  2149.       break;
  2150.   
  2151.     case PASPECT_EDGETYPE: *asf = tsl.edgeattr.type_asf;      
  2152.       break;
  2153.   
  2154.     case PASPECT_EDGEWIDTH: *asf = tsl.edgeattr.width_asf;      
  2155.       break;
  2156.   
  2157.     case PASPECT_EDGE_COLR_IND: *asf = tsl.edgeattr.colr_ind_asf;
  2158.       break;
  2159.   }
  2160. }  /* ptk_inqtslattrasf */
  2161.  
  2162. /*--------------------------------------------------------------------------*/
  2163.  
  2164. /* end of tsl.c */
  2165.